Python 语言xxx笔记

在 Python 中，if __name__ == "__main__": 是一个非常常见的特殊用法，用于区分脚本是直接运行还是作为模块导入。除此之外，Python 中还有一些类似的特殊用法和机制，以下是一些常见的特殊用法及其说明：

1. `if name == "main":`

含义：当一个 Python 文件被直接运行时，__name__ 的值为 "__main__"；当它被作为模块导入时，__name__ 的值为模块名。
用途：用于确保某些代码只在脚本被直接运行时执行，而在模块被导入时不执行。

示例：

def main():
    print("This is the main function")

if __name__ == "__main__":
    main()

2. `init` 方法

含义：__init__ 是类的构造方法，在创建类的实例时会自动调用，用于初始化对象的属性。
用途：为类的实例提供初始值。

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 25)
print(p.name, p.age)

3. `str` 和 `repr` 方法

__str__：定义对象被 print() 或 str() 调用时的字符串表示。
__repr__：定义对象的“官方”字符串表示，通常用于调试或开发。

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name}, {self.age} years old"

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

p = Person("Alice", 25)
print(str(p))  # 输出: Alice, 25 years old
print(repr(p)) # 输出: Person(name=Alice, age=25)

4. 魔术方法（Magic Methods 或 Dunder Methods）

含义：以双下划线开头和结尾的方法，定义了类的特殊行为。
常见魔术方法：
- __add__: 定义加法运算符 +
- __len__: 定义 len() 方法
- __getitem__: 支持用索引访问对象
- __call__: 使对象可以像函数一样被调用

示例：

class MyList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)

    def __getitem__(self, index):
        return self.items[index]

my_list = MyList([1, 2, 3])
print(len(my_list))  # 输出: 3
print(my_list[1])    # 输出: 2

5. `slots`

含义：限制类的属性，防止动态添加其他属性，从而节省内存。
用途：优化内存使用，尤其是当需要创建大量实例时。

示例：

class Person:
    __slots__ = ['name', 'age']

    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 25)
p.name = "Bob"  # 正常
p.address = "USA"  # 报错：AttributeError: 'Person' object has no attribute 'address'

6. `dict`

含义：返回一个字典，包含对象的所有属性及其值。
用途：查看或操作对象的属性。

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 25)
print(p.__dict__)  # 输出: {'name': 'Alice', 'age': 25}

7. `call`

含义：使对象可以像函数一样被调用。
用途：定义对象的“调用”行为。

示例：

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c())  # 输出: 1
print(c())  # 输出: 2

8. `enter` 和 `exit`

含义：用于上下文管理协议，支持 with 语句。
用途：定义资源的初始化和清理操作。

示例：

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()

with FileManager("test.txt", "w") as f:
    f.write("Hello, World!")

9. `all`

含义：定义模块中可被 from module import * 导入的内容。
用途：控制模块的导出内容。

示例：

__all__ = ['func1', 'Class1']

def func1():
    pass

def func2():
    pass

class Class1:
    pass

class Class2:
    pass

10. `getitem` 和 `setitem`

含义：定义对象的索引访问和赋值行为。
用途：使自定义对象表现得像列表或字典。

示例：

class MyDict:
    def __init__(self):
        self.data = {}

    def __getitem__(self, key):
        return self.data.get(key, None)

    def __setitem__(self, key, value):
        self.data[key] = value

d = MyDict()
d['key'] = 'value'
print(d['key'])  # 输出: value

11. `del`

含义：析构方法，在对象被垃圾回收时调用。
用途：释放资源或执行清理操作。

示例：

class Resource:
    def __del__(self):
        print("Resource released")

r = Resource()
del r  # 输出: Resource released

12. `future` 模块

含义：导入未来版本的特性，用于兼容性目的。
用途：在旧版本中使用新版本的功能。

示例：

from __future__ import print_function
print("Hello, World!")  # 使用 Python 3 的 print 函数

补充遗漏的特殊用法和机制

以下是上文未提及或未详细列出的其他特殊用法和机制：

1. `new` 方法

含义：用于控制类的实例化过程，在 __init__ 之前调用。
用途：用于实现单例模式或自定义实例化逻辑。

示例：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

2. `metaclass`

含义：定义类的元类，用于控制类的创建过程。
用途：动态修改类的行为。

示例：

class Meta(type):
    def __new__(cls, name, bases, dct):
        dct['added_attribute'] = True
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

print(MyClass.added_attribute)  # 输出: True

3. `annotations`

含义：保存变量和函数的类型注解。
用途：用于类型检查和文档生成。

示例：

def func(x: int, y: str) -> bool:
    return True

print(func.__annotations__)  # 输出: {'x': <class 'int'>, 'y': <class 'str'>, 'return': <class 'bool'>}

4. `doc`

含义：存储模块、类或函数的文档字符串。
用途：用于生成帮助文档。

示例：

class MyClass:
    """This is a sample class."""
    pass

print(MyClass.__doc__)  # 输出: This is a sample class.

5. `module` 和 `qualname`

含义：
- __module__：表示类或函数所在的模块。
- __qualname__：表示类或函数的限定名称（包括嵌套类的名称）。
用途：用于调试或反射。

示例：

class Outer:
    class Inner:
        pass

print(Outer.Inner.__module__)   # 输出: __main__
print(Outer.Inner.__qualname__) # 输出: Outer.Inner

6. `hash` 和 `eq`

含义：定义对象的哈希值和相等性判断。
用途：用于在集合或字典中使用自定义对象作为键。

示例：

class MyClass:
    def __init__(self, value):
        self.value = value

    def __hash__(self):
        return hash(self.value)

    def __eq__(self, other):
        return self.value == other.value

a = MyClass(10)
b = MyClass(10)
print(hash(a) == hash(b))  # 输出: True
print(a == b)             # 输出: True

7. `iter` 和 `next`

含义：定义对象的迭代行为。
用途：使对象可迭代。

示例：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

it = MyIterator([1, 2, 3])
for item in it:
    print(item)  # 输出: 1, 2, 3

8. `format`

含义：定义对象的格式化行为，支持 str.format() 和 f-string。
用途：自定义格式化输出。

示例：

class MyClass:
    def __init__(self, value):
        self.value = value

    def __format__(self, format_spec):
        return f"MyClass: {self.value:{format_spec}}"

print(f"{MyClass(42):>10}")  # 输出: MyClass:         42

9. `sizeof`

含义：返回对象占用的内存大小。
用途：用于内存优化。

示例：

import sys
x = [1, 2, 3]
print(sys.getsizeof(x))  # 输出: 对象的字节大小

10. `getattr` 和 `setattr`

含义：拦截对象属性的获取和设置操作。
用途：动态处理属性。

示例：

class MyClass:
    def __getattr__(self, name):
        return f"{name} not found"

    def __setattr__(self, name, value):
        print(f"Setting {name} to {value}")
        super().__setattr__(name, value)

obj = MyClass()
print(obj.some_attribute)  # 输出: some_attribute not found
obj.some_attribute = 42    # 输出: Setting some_attribute to 42

11. `import`

含义：动态导入模块。
用途：在运行时导入模块。
示例：

   module = __import__('math')
   print(module.sqrt(16))  # 输出: 4.0

1. if __name__ == "__main__":​

2. __init__ 方法​

3. __str__ 和 __repr__ 方法​

4. 魔术方法（Magic Methods 或 Dunder Methods）​

5. __slots__​

6. __dict__​

7. __call__​

8. __enter__ 和 __exit__​

9. __all__​

10. __getitem__ 和 __setitem__​

11. __del__​

12. __future__ 模块​

补充遗漏的特殊用法和机制​

1. __new__ 方法​

2. __metaclass__​

3. __annotations__​

4. __doc__​

5. __module__ 和 __qualname__​

6. __hash__ 和 __eq__​

7. __iter__ 和 __next__​

8. __format__​

9. __sizeof__​

10. __getattr__ 和 __setattr__​

11. __import__​